/*
    * Copyright (c) 2003, 2004, Oracle and/or its affiliates. All rights reserved.
    * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    *
    * This code is free software; you can redistribute it and/or modify it
    * under the terms of the GNU General Public License version 2 only, as
    * published by the Free Software Foundation.
    *
    * This code is distributed in the hope that it will be useful, but WITHOUT
   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   * version 2 for more details (a copy is included in the LICENSE file that
   * accompanied this code).
   *
   * You should have received a copy of the GNU General Public License version
   * 2 along with this work; if not, write to the Free Software Foundation,
   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   * or visit www.oracle.com if you need additional information or have any
   * questions.
   */
  
  /* @test
   * @bug 4287596
   * @summary Unit test for "Pluggable Connectors and Transports" feature.
   *
   * This test checks that VirtualMachineManager creates Connectors that
   * are "compatible" those created by 1.4 or earilier releases.
   */
  
  import com.sun.jdi.*;
  import com.sun.jdi.connect.*;
  import java.util.*;
  
  public class CompatibleConnectors {
  
      // number of tests that fail
      static int failures;
  
      static void fail(String msg) {
          System.out.println(msg + " - test failed.");
          failures++;
      }
  
      // the AttachingConnectors that we expect
      static Object[][] attachingConnectors() {
          return new Object[][] {
              { "com.sun.jdi.SocketAttach",
                "dt_socket",
                new String[] { "hostname", "Connector.StringArgument", "false" },
                new String[] { "port",     "Connector.IntegerArgument", "true" }
              },
  
              { "com.sun.jdi.SharedMemoryAttach",
                "dt_shmem",
                new String[] { "name", "Connector.StringArgument", "true" }
              }
          };
      }
  
      // the ListeningConnectors that we expect
      static Object[][] listeningConnectors() {
          return new Object[][] {
              { "com.sun.jdi.SocketListen",
                "dt_socket",
                new String[] { "port", "Connector.IntegerArgument", "true" }
              },
  
              { "com.sun.jdi.SharedMemoryListen",
                "dt_shmem",
                new String[] { "name", "Connector.StringArgument", "false" }
              }
          };
  
      }
  
      // the LaunchingConnectors that we expect
      // - note that we don't indicate the transport name (as it varies
      // for these connectors)
      static Object[][] launchingConnectors() {
          return new Object[][] {
              { "com.sun.jdi.CommandLineLaunch",
                null,
                new String[] { "home",    "Connector.StringArgument",     "false" },
                new String[] { "options", "Connector.StringArgument",     "false" },
                new String[] { "main",    "Connector.StringArgument",     "true"  },
                new String[] { "suspend", "Connector.BooleanArgument",    "false" },
                new String[] { "quote",   "Connector.StringArgument",     "true"  },
                new String[] { "vmexec",  "Connector.StringArgument",     "true" }
              },
  
              { "com.sun.jdi.RawCommandLineLaunch",
                null,
                new String[] { "command",  "Connector.StringArgument",     "true" },
                new String[] { "address",  "Connector.StringArgument",     "true" },
                new String[] { "quote",    "Connector.StringArgument",     "true" }
              }
          };
 
     }
 
     // find Connector by name, return null if not found
     static Connector find(String name, List l) {
         Iterator i = l.iterator();
         while (i.hasNext()) {
             Connector c = (Connector)i.next();
             if (c.name().equals(name)) {
                 return c;
             }
         }
         return null;
     }
 
     // check that a connector is of the expected type
     static void type_match(String arg_name, String arg_type, Connector.Argument arg) {
         boolean fail = false;
         if (arg_type.equals("Connector.StringArgument")) {
             if (!(arg instanceof Connector.StringArgument)) {
                 fail = true;
             }
         }
         if (arg_type.equals("Connector.IntegerArgument")) {
             if (!(arg instanceof Connector.IntegerArgument)) {
                 fail = true;
             }
         }
         if (arg_type.equals("Connector.BooleanArgument")) {
             if (!(arg instanceof Connector.BooleanArgument)) {
                 fail = true;
             }
         }
         if (arg_type.equals("Connector.SelectedArgument")) {
             if (!(arg instanceof Connector.IntegerArgument)) {
                 fail = true;
             }
         }
         if (fail) {
             fail(arg_name + " is of type: " + arg.getClass() + ", expected: "
                  + arg_type);
         }
     }
 
 
     // check that a Connector is compatible
     static void check(Object[] desc, Connector connector) {
         String name = (String)desc[0];
         String transport_name = (String)desc[1];
 
         // if the transport name is "null" it means its transport may
         // vary (eg: SunCommandLineLauncher will choose shared memory
         // on Windows and dt_socket on Solaris). In that case we can't
         // check the transport name.
         //
         if (transport_name != null) {
             System.out.println("Checking transpot name");
             if (!(transport_name.equals(connector.transport().name()))) {
                 fail("transport().name() returns: " +
                     connector.transport().name() + ", expected: " + transport_name);
             }
         }
 
         // check that all the old arguments still exist
         for (int i=2; i<desc.length; i++) {
             String[] args = (String[])desc[i];
             String arg_name = args[0];
             String arg_type = args[1];
             String arg_mandatory = args[2];
 
             System.out.println("Checking argument: " + arg_name);
 
             // check that the arg still exists
             Map defaultArgs = connector.defaultArguments();
             Object value = defaultArgs.get(arg_name);
             if (value == null) {
                 fail(name + " is missing Connector.Argument: " + arg_name);
                 continue;
             }
 
             // next check that the type matches
             Connector.Argument connector_arg = (Connector.Argument)value;
 
             // check that the argument type hasn't changed
             type_match(arg_name, arg_type, connector_arg);
 
             // check that an optional argument has been made mandatory
             if (arg_mandatory.equals("false")) {
                 if (connector_arg.mustSpecify()) {
                     fail(arg_name + " is now mandatory");
                 }
             }
         }
 
         // next we check for new arguments that are mandatory but
         // have no default value
 
         System.out.println("Checking for new arguments");
         Map dfltArgs = connector.defaultArguments();
         Iterator iter = dfltArgs.keySet().iterator();
         while (iter.hasNext()) {
             String arg_name = (String)iter.next();
 
             // see if the argument is new
             boolean found = false;
             for (int j=2; j<desc.length; j++) {
                 String[] args = (String[])desc[j];
                 if (args[0].equals(arg_name)) {
                     found = true;
                     break;
                 }
             }
 
             if (!found) {
                 Connector.Argument connector_arg =
                     (Connector.Argument)dfltArgs.get(arg_name);
 
                 if (connector_arg.mustSpecify()) {
                     String value = connector_arg.value();
                     if (value.equals("")) {
                         value = null;
                     }
                     if (value == null) {
                         fail("New Connector.Argument \"" + connector_arg.name() +
                             "\" added - argument is mandatory");
                     }
                 }
             }
         }
     }
 
 
     // compare the actual list of Connectors against the
     // expected list of Connectors.
     static void compare(Object[][] prev, List list) {
         String os = System.getProperty("os.name");
         for (int i=0; i<prev.length; i++) {
             Object[] desc = prev[i];
             String name = (String)desc[0];
 
             // ignore Windows specific Connectors are non-Windows machines
             if (!(os.startsWith("Windows"))) {
                 if (name.equals("com.sun.jdi.SharedMemoryAttach") ||
                     name.equals("com.sun.jdi.SharedMemoryListen")) {
                     continue;
                 }
             }
 
             System.out.println("");
             System.out.println("Checking Connector " + name);
 
             // check that the Connector exists
             Connector c = find(name, list);
             if (c == null) {
                 fail("Connector is missing");
                 continue;
             }
 
             check(desc, c);
         }
     }
 
     public static void main(String args[]) throws Exception {
         VirtualMachineManager vmm = Bootstrap.virtualMachineManager();
 
         // in 1.2/1.3/1.4 the defualtConnector was
         // com.sun.jdi.CommandLineLaunch. Many debuggers probably
         // depend on this so check that it's always the default.
         //
         String expected = "com.sun.jdi.CommandLineLaunch";
         System.out.println("Checking that defaultConnector is: " + expected);
         String dflt = vmm.defaultConnector().name();
         if (!(dflt.equals(expected))) {
             System.err.println("defaultConnector() is: " + dflt +
                 ", expected:" + expected);
             failures++;
         } else {
             System.out.println("Okay");
         }
 
         compare(attachingConnectors(), vmm.attachingConnectors());
         compare(listeningConnectors(), vmm.listeningConnectors());
         compare(launchingConnectors(), vmm.launchingConnectors());
 
         // test results
         if (failures > 0) {
             System.out.println("");
             throw new RuntimeException(failures + " test(s) failed");
         }
     }
 }